package com.example.forum.controller;

import com.example.forum.common.AppResult;
import com.example.forum.common.ResultCode;
import com.example.forum.config.AppConfig;
import com.example.forum.model.User;
import com.example.forum.services.ISystemConfigService;
import com.example.forum.services.IUserService;
import com.example.forum.utils.MD5Util;
import com.example.forum.utils.StringUtil;
import com.example.forum.utils.UUIDUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.validation.constraints.NotNull;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;

@Api(tags = "管理员接口")
@Slf4j
@RestController
@RequestMapping("/admin")
public class AdminController {
    
    @Resource
    private IUserService userService;
    
    @Resource
    private ISystemConfigService systemConfigService;
    
    /**
     * 检查当前用户是否为管理员
     * @param request HTTP请求，用于获取Session
     * @return 是管理员返回成功，否则返回错误
     */
    @ApiOperation("检查是否为管理员权限")
    @GetMapping("/check")
    public AppResult checkAdmin(HttpServletRequest request) {
        // 从session获取登录信息
        HttpSession session = request.getSession(false);
        if (session == null) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        User user = (User) session.getAttribute(AppConfig.USER_SESSION);
        if (user == null || user.getIsAdmin() != 1) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        return AppResult.success();
    }
    
    /**
     * 获取管理后台仪表盘数据
     * @param request HTTP请求，用于获取Session
     * @return 仪表盘数据
     */
    @ApiOperation("获取管理后台仪表盘数据")
    @GetMapping("/dashboard")
    public AppResult getDashboardData(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 获取系统统计信息
        Map<String, Object> stats = userService.getSystemStats();
        
        // 计算增长率（这里使用模拟数据，实际应基于历史数据计算）
        Random random = new Random();
        stats.put("userGrowthRate", random.nextInt(20) - 5);
        stats.put("articleGrowthRate", random.nextInt(15));
        stats.put("commentGrowthRate", random.nextInt(25) - 2);
        stats.put("totalVisits", random.nextInt(10000) + 1000);
        stats.put("visitGrowthRate", random.nextInt(30) - 10);
        
        return AppResult.success(stats);
    }
    
    /**
     * 获取访问趋势数据
     * @param request HTTP请求，用于获取Session
     * @param period 时间周期（week/month/year）
     * @return 访问趋势数据
     */
    @ApiOperation("获取访问趋势数据")
    @GetMapping("/stat/visit-trend")
    public AppResult getVisitTrend(HttpServletRequest request,
                                  @ApiParam("时间周期(week/month/year)") @RequestParam(value = "period", defaultValue = "week") String period) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 这里简单模拟访问趋势数据，实际应从数据库或日志系统获取
        List<Map<String, Object>> trendData = new ArrayList<>();
        LocalDate startDate;
        int days;
        
        // 根据周期确定数据点数量和起始日期
        switch (period) {
            case "week":
                startDate = LocalDate.now().minusDays(6);
                days = 7;
                break;
            case "month":
                startDate = LocalDate.now().minusDays(29);
                days = 30;
                break;
            case "year":
                // 对于年，每月一个数据点
                startDate = LocalDate.now().minusMonths(11);
                days = 12;
                break;
            default:
                startDate = LocalDate.now().minusDays(6);
                days = 7;
                break;
        }
        
        // 生成模拟数据
        Random random = new Random();
        DateTimeFormatter formatter;
        
        if ("year".equals(period)) {
            formatter = DateTimeFormatter.ofPattern("yyyy-MM");
            for (int i = 0; i < days; i++) {
                Map<String, Object> point = new HashMap<>();
                LocalDate date = startDate.plusMonths(i);
                point.put("date", date.format(formatter));
                point.put("value", random.nextInt(1000) + 500);
                trendData.add(point);
            }
        } else {
            formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            for (int i = 0; i < days; i++) {
                Map<String, Object> point = new HashMap<>();
                LocalDate date = startDate.plusDays(i);
                point.put("date", date.format(formatter));
                point.put("value", random.nextInt(200) + 50);
                trendData.add(point);
            }
        }
        
        return AppResult.success(trendData);
    }
    
    /**
     * 获取设备分布数据
     * @param request HTTP请求，用于获取Session
     * @return 设备分布数据
     */
    @ApiOperation("获取设备分布数据")
    @GetMapping("/stat/device-distribution")
    public AppResult getDeviceDistribution(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 这里简单模拟设备分布数据，实际应从日志系统获取
        List<Map<String, Object>> deviceData = new ArrayList<>();
        Map<String, Object> desktop = new HashMap<>();
        desktop.put("name", "桌面端");
        desktop.put("value", 65);
        
        Map<String, Object> mobile = new HashMap<>();
        mobile.put("name", "移动端");
        mobile.put("value", 32);
        
        Map<String, Object> tablet = new HashMap<>();
        tablet.put("name", "平板设备");
        tablet.put("value", 3);
        
        deviceData.add(desktop);
        deviceData.add(mobile);
        deviceData.add(tablet);
        
        return AppResult.success(deviceData);
    }
    
    /**
     * 获取所有用户列表（管理员功能）
     * @param request HTTP请求，用于获取Session
     * @return 用户列表
     */
    @ApiOperation("获取所有用户列表")
    @GetMapping("/users")
    public AppResult<List<User>> getAllUsers(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        List<User> users = userService.getAllUsers();
        return AppResult.success(users);
    }
    
    /**
     * 分页获取用户列表（管理员功能）
     * @param request HTTP请求，用于获取Session
     * @param page 页码
     * @param size 每页大小
     * @param sort 排序字段
     * @param order 排序方向
     * @return 用户列表
     */
    @ApiOperation("分页获取用户列表")
    @GetMapping("/user/list")
    public AppResult getUserList(HttpServletRequest request,
                               @ApiParam("页码") @RequestParam(value = "page", defaultValue = "1") int page,
                               @ApiParam("每页大小") @RequestParam(value = "size", defaultValue = "10") int size,
                               @ApiParam("排序字段") @RequestParam(value = "sort", defaultValue = "createTime") String sort,
                               @ApiParam("排序方向") @RequestParam(value = "order", defaultValue = "desc") String order) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 调用服务层获取分页数据
        Map<String, Object> result = userService.getUsersByPage(page, size, sort, order);
        
        return AppResult.success(result);
    }
    
    /**
     * 设置用户禁言状态（管理员功能）
     * @param request HTTP请求，用于获取Session
     * @param userId 用户ID
     * @param state 状态值（0正常，1禁言）
     * @return 操作结果
     */
    @ApiOperation("设置用户禁言状态")
    @PostMapping("/user/state")
    public AppResult setUserState(HttpServletRequest request,
                                  @ApiParam("用户ID") @RequestParam("userId") @NotNull Long userId,
                                  @ApiParam("状态值（0正常，1禁言）") @RequestParam("state") @NotNull Byte state) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        userService.updateUserState(userId, state);
        return AppResult.success();
    }
    
    /**
     * 管理员创建用户
     * @param request HTTP请求，用于获取Session
     * @param username 用户名
     * @param nickname 昵称
     * @param password 密码
     * @param passwordRepeat 确认密码
     * @param email 邮箱（可选）
     * @param gender 性别
     * @param role 角色
     * @param status 状态
     * @return 操作结果
     */
    @ApiOperation("管理员创建用户")
    @PostMapping("/user/create")
    public AppResult createUser(HttpServletRequest request,
                               @ApiParam("用户名") @RequestParam("username") @NotNull String username,
                               @ApiParam("昵称") @RequestParam("nickname") @NotNull String nickname,
                               @ApiParam("密码") @RequestParam("password") @NotNull String password,
                               @ApiParam("确认密码") @RequestParam("passwordRepeat") @NotNull String passwordRepeat,
                               @ApiParam("邮箱") @RequestParam(value = "email", required = false) String email,
                               @ApiParam("性别") @RequestParam(value = "gender", required = false, defaultValue = "2") Byte gender,
                               @ApiParam("角色") @RequestParam(value = "role", required = false) String role,
                               @ApiParam("状态") @RequestParam(value = "status", required = false) String status) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 校验两次密码是否相同
        if (!password.equals(passwordRepeat)) {
            log.warn(ResultCode.FAILED_TWO_PWD_NOT_SAME.toString());
            return AppResult.failed(ResultCode.FAILED_TWO_PWD_NOT_SAME);
        }
        
        try {
            // 准备数据
            User user = new User();
            user.setUsername(username);
            user.setNickname(nickname);
            
            // 设置性别
            user.setGender(gender);
            
            // 设置邮箱（如果有）
            if (!StringUtil.isEmpty(email)) {
                user.setEmail(email);
            }
            
            // 对密码加盐
            String salt = UUIDUtils.UUID_32();
            String encryptPassword = MD5Util.md5Salt(password, salt);
            user.setPassword(encryptPassword);
            user.setSalt(salt);
            
            // 设置角色（如果指定了）
            if ("ADMIN".equals(role)) {
                user.setIsAdmin((byte) 1);
            } else {
                user.setIsAdmin((byte) 0);
            }
            
            // 设置状态（如果指定了）
            if ("DISABLED".equals(status)) {
                user.setState((byte) 1);
            } else {
                user.setState((byte) 0);
            }
            
            // 设置创建时间和更新时间
            user.setCreateTime(new java.util.Date());
            user.setUpdateTime(new java.util.Date());
            
            // 执行添加操作
            userService.createUser(user);
            
            return AppResult.success();
        } catch (Exception e) {
            log.error("创建用户失败", e);
            return AppResult.failed("创建用户失败: " + e.getMessage());
        }
    }
    
    /**
     * 删除用户（管理员功能）
     * @param request HTTP请求，用于获取Session
     * @param userId 用户ID
     * @return 操作结果
     */
    @ApiOperation("删除用户")
    @PostMapping("/user/delete")
    public AppResult deleteUser(HttpServletRequest request,
                               @ApiParam("用户ID") @RequestParam("userId") @NotNull Long userId) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        userService.deleteUser(userId);
        return AppResult.success();
    }
    
    /**
     * 设置用户为管理员（超级管理员功能）
     * @param request HTTP请求，用于获取Session
     * @param userId 用户ID
     * @param isAdmin 是否为管理员（0普通用户，1管理员）
     * @return 操作结果
     */
    @ApiOperation("设置用户为管理员")
    @PostMapping("/user/admin")
    public AppResult setUserAdmin(HttpServletRequest request,
                                 @ApiParam("用户ID") @RequestParam("userId") @NotNull Long userId,
                                 @ApiParam("是否为管理员（0普通用户，1管理员）") @RequestParam("isAdmin") @NotNull Byte isAdmin) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 执行权限更新
        userService.updateUserAdmin(userId, isAdmin);
        
        // 检查更新的用户是否为当前会话用户，如果是则更新会话信息
        HttpSession session = request.getSession(false);
        if (session != null) {
            User sessionUser = (User) session.getAttribute(AppConfig.USER_SESSION);
            if (sessionUser != null && sessionUser.getId().equals(userId)) {
                // 获取更新后的用户信息
                User updatedUser = userService.selectById(userId);
                // 更新会话中的用户信息
                session.setAttribute(AppConfig.USER_SESSION, updatedUser);
                log.info("用户在会话中的权限已更新，userId={}, isAdmin={}", userId, isAdmin);
            }
        }
        
        return AppResult.success();
    }
    
    /**
     * 管理员更新用户信息
     * @param request HTTP请求，用于获取Session
     * @param id 用户ID
     * @param username 用户名
     * @param nickname 昵称
     * @param gender 性别
     * @param email 邮箱
     * @param phoneNum 手机号
     * @param isAdmin 是否为管理员（0普通用户，1管理员）
     * @param state 状态（0正常，1禁用）
     * @param remark 备注
     * @return 操作结果
     */
    @ApiOperation("管理员更新用户信息")
    @PostMapping("/user/update")
    public AppResult updateUser(HttpServletRequest request,
                               @ApiParam("用户ID") @RequestParam("id") @NotNull Long id,
                               @ApiParam("用户名") @RequestParam(value = "username", required = false) String username,
                               @ApiParam("昵称") @RequestParam(value = "nickname", required = false) String nickname,
                               @ApiParam("性别") @RequestParam(value = "gender", required = false) Byte gender,
                               @ApiParam("邮箱") @RequestParam(value = "email", required = false) String email,
                               @ApiParam("手机号") @RequestParam(value = "phoneNum", required = false) String phoneNum,
                               @ApiParam("是否为管理员") @RequestParam(value = "isAdmin", required = false) Byte isAdmin,
                               @ApiParam("状态") @RequestParam(value = "state", required = false) Byte state,
                               @ApiParam("备注") @RequestParam(value = "remark", required = false) String remark) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 获取要更新的用户
        User existingUser = userService.selectById(id);
        if (existingUser == null) {
            return AppResult.failed("用户不存在");
        }
        
        // 创建更新对象
        User updateUser = new User();
        updateUser.setId(id);
        
        // 设置要更新的字段
        if (username != null) {
            updateUser.setUsername(username);
        }
        if (nickname != null) {
            updateUser.setNickname(nickname);
        }
        if (gender != null) {
            updateUser.setGender(gender);
        }
        if (email != null) {
            updateUser.setEmail(email);
        }
        if (phoneNum != null) {
            updateUser.setPhoneNum(phoneNum);
        }
        if (isAdmin != null) {
            updateUser.setIsAdmin(isAdmin);
        }
        if (state != null) {
            updateUser.setState(state);
        }
        if (remark != null) {
            updateUser.setRemark(remark);
        }
        
        // 设置更新时间
        updateUser.setUpdateTime(new java.util.Date());
        
        // 执行更新
        userService.updateUserByAdmin(updateUser);
        
        return AppResult.success();
    }
    
    /**
     * 查看系统统计信息（管理员功能）
     * @param request HTTP请求，用于获取Session
     * @return 系统统计信息
     */
    @ApiOperation("查看系统统计信息")
    @GetMapping("/stats")
    public AppResult getSystemStats(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 调用服务获取系统统计信息
        return AppResult.success(userService.getSystemStats());
    }
    
    /**
     * 获取用户数量统计
     * @param request HTTP请求，用于获取Session
     * @return 用户统计信息，包含total和today两个字段
     */
    @ApiOperation("获取用户数量统计")
    @GetMapping("/user/count")
    public AppResult getUserCount(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        Map<String, Object> countMap = new HashMap<>();
        // 获取总用户数
        int totalUsers = userService.countTotalUsers();
        // 获取今日新增用户数
        int todayNewUsers = userService.countTodayNewUsers();
        
        countMap.put("total", totalUsers);
        countMap.put("today", todayNewUsers);
        
        return AppResult.success(countMap);
    }
    
    /**
     * 获取系统基本设置
     * @param request HTTP请求，用于获取Session
     * @return 系统基本设置
     */
    @ApiOperation("获取系统基本设置")
    @GetMapping("/settings/basic")
    public AppResult getBasicSettings(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        Map<String, String> settings = systemConfigService.getBasicSettings();
        return AppResult.success(settings);
    }
    
    /**
     * 保存系统基本设置
     * @param request HTTP请求，用于获取Session
     * @param settings 系统基本设置
     * @return 操作结果
     */
    @ApiOperation("保存系统基本设置")
    @PostMapping("/settings/basic")
    public AppResult saveBasicSettings(HttpServletRequest request, @RequestBody Map<String, String> settings) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        if (settings == null || settings.isEmpty()) {
            return AppResult.failed("设置内容不能为空");
        }
        
        boolean success = systemConfigService.saveBasicSettings(settings);
        if (success) {
            return AppResult.success();
        } else {
            return AppResult.failed("保存基本设置失败");
        }
    }
    
    /**
     * 获取内容设置
     * @param request HTTP请求，用于获取Session
     * @return 内容设置
     */
    @ApiOperation("获取内容设置")
    @GetMapping("/settings/content")
    public AppResult getContentSettings(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        Map<String, String> settings = systemConfigService.getContentSettings();
        return AppResult.success(settings);
    }
    
    /**
     * 保存内容设置
     * @param request HTTP请求，用于获取Session
     * @param settings 内容设置
     * @return 操作结果
     */
    @ApiOperation("保存内容设置")
    @PostMapping("/settings/content")
    public AppResult saveContentSettings(HttpServletRequest request, @RequestBody Map<String, String> settings) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        if (settings == null || settings.isEmpty()) {
            return AppResult.failed("设置内容不能为空");
        }
        
        boolean success = systemConfigService.saveContentSettings(settings);
        if (success) {
            return AppResult.success();
        } else {
            return AppResult.failed("保存内容设置失败");
        }
    }
    
    /**
     * 获取邮件设置
     * @param request HTTP请求，用于获取Session
     * @return 邮件设置
     */
    @ApiOperation("获取邮件设置")
    @GetMapping("/settings/email")
    public AppResult getEmailSettings(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        Map<String, String> settings = systemConfigService.getEmailSettings();
        // 出于安全考虑，不返回邮箱密码
        settings.remove("email.password");
        return AppResult.success(settings);
    }
    
    /**
     * 保存邮件设置
     * @param request HTTP请求，用于获取Session
     * @param settings 邮件设置
     * @return 操作结果
     */
    @ApiOperation("保存邮件设置")
    @PostMapping("/settings/email")
    public AppResult saveEmailSettings(HttpServletRequest request, @RequestBody Map<String, String> settings) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        if (settings == null || settings.isEmpty()) {
            return AppResult.failed("设置内容不能为空");
        }
        
        boolean success = systemConfigService.saveEmailSettings(settings);
        if (success) {
            return AppResult.success();
        } else {
            return AppResult.failed("保存邮件设置失败");
        }
    }
    
    /**
     * 获取第三方集成设置
     * @param request HTTP请求，用于获取Session
     * @return 第三方集成设置
     */
    @ApiOperation("获取第三方集成设置")
    @GetMapping("/settings/integration")
    public AppResult getIntegrationSettings(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        Map<String, String> settings = systemConfigService.getIntegrationSettings();
        // 出于安全考虑，不返回客户端密钥
        settings.remove("integration.githubClientSecret");
        settings.remove("integration.googleClientSecret");
        return AppResult.success(settings);
    }
    
    /**
     * 保存第三方集成设置
     * @param request HTTP请求，用于获取Session
     * @param settings 第三方集成设置
     * @return 操作结果
     */
    @ApiOperation("保存第三方集成设置")
    @PostMapping("/settings/integration")
    public AppResult saveIntegrationSettings(HttpServletRequest request, @RequestBody Map<String, String> settings) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        if (settings == null || settings.isEmpty()) {
            return AppResult.failed("设置内容不能为空");
        }
        
        boolean success = systemConfigService.saveIntegrationSettings(settings);
        if (success) {
            return AppResult.success();
        } else {
            return AppResult.failed("保存第三方集成设置失败");
        }
    }
    
    /**
     * 获取所有系统设置
     * @param request HTTP请求，用于获取Session
     * @return 所有系统设置
     */
    @ApiOperation("获取所有系统设置")
    @GetMapping("/settings")
    public AppResult getAllSettings(HttpServletRequest request) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        Map<String, Object> allSettings = new HashMap<>();
        allSettings.put("basic", systemConfigService.getBasicSettings());
        allSettings.put("content", systemConfigService.getContentSettings());
        
        Map<String, String> emailSettings = systemConfigService.getEmailSettings();
        // 出于安全考虑，不返回邮箱密码
        emailSettings.remove("email.password");
        allSettings.put("email", emailSettings);
        
        Map<String, String> integrationSettings = systemConfigService.getIntegrationSettings();
        // 出于安全考虑，不返回客户端密钥
        integrationSettings.remove("integration.githubClientSecret");
        integrationSettings.remove("integration.googleClientSecret");
        allSettings.put("integration", integrationSettings);
        
        return AppResult.success(allSettings);
    }
    
    /**
     * 测试邮件发送
     * @param request HTTP请求，用于获取Session
     * @param email 测试邮箱地址
     * @return 操作结果
     */
    @ApiOperation("测试邮件发送")
    @PostMapping("/settings/email/test")
    public AppResult testEmailSending(HttpServletRequest request,
                                    @ApiParam("测试邮箱地址") @RequestParam("email") String email) {
        // 验证管理员权限
        if (!isAdmin(request)) {
            return AppResult.failed(ResultCode.FAILED_UNAUTHORIZED);
        }
        
        // 这里我们只做一个模拟，实际实现中需要调用邮件发送服务
        log.info("准备向 {} 发送测试邮件", email);
        
        // 延迟一些时间模拟邮件发送过程
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return AppResult.success("测试邮件已发送，请检查收件箱");
    }
    
    /**
     * 辅助方法：检查当前用户是否为管理员
     * @param request HTTP请求
     * @return 是否为管理员
     */
    private boolean isAdmin(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session == null) {
            return false;
        }
        
        User user = (User) session.getAttribute(AppConfig.USER_SESSION);
        return user != null && user.getIsAdmin() == 1;
    }
} 